
var _typeof = function(o) {
    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
        return typeof o;
    } : function(o) {
        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
    }, _typeof(o);
}

var _toPrimitive = function(r, t) {
    if ("object" !== _typeof(r) || null === r) return r;
    var e = r[Symbol.toPrimitive];
    if (void 0 !== e) {
        var i = e.call(r, t || "default");
        if ("object" !== _typeof(i)) return i;
        throw new TypeError("@@toPrimitive must return a primitive value.");
    }
    return ("string" === t ? String : Number)(r);
}

var _toPropertyKey = function(r) {
    var t = _toPrimitive(r, "string");
    return "symbol" === _typeof(t) ? t : String(t);
}

var _defineProperty = function(e, r, t) {
    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
        value: t,
        enumerable: !0,
        configurable: !0,
        writable: !0
    }) : e[r] = t, e;
}

var ownKeys = function(e, r) {
    var t = Object.keys(e);
    if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r) {
            return Object.getOwnPropertyDescriptor(e, r).enumerable;
        })), t.push.apply(t, o);
    }
    return t;
}

var _objectSpread2 = function(e) {
    for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
            _defineProperty(e, r, t[r]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
            Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
        });
    }
    return e;
}

window.babel_objectSpread2 = _objectSpread2;

var _arrayLikeToArray = function (r, a) {
    (null == a || a > r.length) && (a = r.length);
    for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
    return n;
}

var _arrayWithoutHoles = function (r) {
    if (Array.isArray(r)) return _arrayLikeToArray(r);
}

var _iterableToArray = function (r) {
    if ("undefined" != typeof Symbol && Symbol.iterator in Object(r)) return Array.from(r);
}

var _unsupportedIterableToArray = function (r, e) {
    if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, e);
        var t = Object.prototype.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, e) : void 0;
    }
}

var _nonIterableSpread = function () {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

var _toConsumableArray = function (r) {
    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}

// window._toConsumableArray2 = _toConsumableArray;
window.babel_toConsumableArray = _toConsumableArray;
var _arrayWithHoles = function(r) {
    if (Array.isArray(r)) return r;
}
var _iterableToArrayLimit = function(r, t) {
    if ("undefined" != typeof Symbol && Symbol.iterator in Object(r)) {
        var e = [], i = !0, o = !1, l = void 0;
        try {
            for (var n, a = r[Symbol.iterator](); !(i = (n = a.next()).done) && (e.push(n.value), 
            !t || e.length !== t); i = !0) ;
        } catch (r) {
            o = !0, l = r;
        } finally {
            try {
                i || null == a.return || a.return();
            } finally {
                if (o) throw l;
            }
        }
        return e;
    }
}

var _arrayLikeToArray = function(r, a) {
    (null == a || a > r.length) && (a = r.length);
    for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
    return n;
}

var _unsupportedIterableToArray = function(r, e) {
    if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, e);
        var t = Object.prototype.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, e) : void 0;
    }
}
var _nonIterableRest = function() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

var _slicedToArray = function(r, e) {
    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}

window.babel_slicedToArray = _slicedToArray;
var _defineProperty = function(e, r, n) {
    return r in e ? Object.defineProperty(e, r, {
        value: n,
        enumerable: !0,
        configurable: !0,
        writable: !0
    }) : e[r] = n, e
}
// module.exports = _defineProperty;

window.babel_defineProperty = _defineProperty;
var _regeneratorRuntime = function(params) {
    let e = {}, n = Object.prototype, o = n.hasOwnProperty, i = Object.defineProperty || function(t, r, e) {
        t[r] = e.value;
    }, a = "function" == typeof Symbol ? Symbol : {}, c = a.iterator || "@@iterator", u = a.asyncIterator || "@@asyncIterator", l = a.toStringTag || "@@toStringTag";
    function h(t, r, e) {
        return Object.defineProperty(t, r, {
            value: e,
            enumerable: !0,
            configurable: !0,
            writable: !0
        }), t[r];
    }
    try {
        h({}, "");
    } catch (t) {
        h = function(t, r, e) {
            return t[r] = e;
        };
    }
    function f(t, r, e, n) {
        var o = r && r.prototype instanceof d ? r : d, a = Object.create(o.prototype), c = new k(n || []);
        return i(a, "_invoke", {
            value: E(t, e, c)
        }), a;
    }
    function s(t, r, e) {
        try {
            return {
                type: "normal",
                arg: t.call(r, e)
            };
        } catch (t) {
            return {
                type: "throw",
                arg: t
            };
        }
    }
    e.wrap = f;
    var p = {};
    function d() {}
    function v() {}
    function y() {}
    var g = {};
    h(g, c, function() {
        return this;
    });
    var m = Object.getPrototypeOf, w = m && m(m(G([])));
    w && w !== n && o.call(w, c) && (g = w);
    var x = y.prototype = d.prototype = Object.create(g);
    function L(t) {
        [ "next", "throw", "return" ].forEach(function(r) {
            h(t, r, function(t) {
                return this._invoke(r, t);
            });
        });
    }
    function b(r, e) {
        function n(i, a, c, u) {
            var l = s(r[i], r, a);
            if ("throw" !== l.type) {
                var h = l.arg, f = h.value;
                return f && "object" == t(f) && o.call(f, "__await") ? e.resolve(f.__await).then(function(t) {
                    n("next", t, c, u);
                }, function(t) {
                    n("throw", t, c, u);
                }) : e.resolve(f).then(function(t) {
                    h.value = t, c(h);
                }, function(t) {
                    return n("throw", t, c, u);
                });
            }
            u(l.arg);
        }
        var a;
        i(this, "_invoke", {
            value: function(t, r) {
                function o() {
                    return new e(function(e, o) {
                        n(t, r, e, o);
                    });
                }
                return a = a ? a.then(o, o) : o();
            }
        });
    }
    function E(t, r, e) {
        var n = "suspendedStart";
        return function(o, i) {
            if ("executing" === n) throw new Error("Generator is already running");
            if ("completed" === n) {
                if ("throw" === o) throw i;
                return N();
            }
            for (e.method = o, e.arg = i; ;) {
                var a = e.delegate;
                if (a) {
                    var c = _(a, e);
                    if (c) {
                        if (c === p) continue;
                        return c;
                    }
                }
                if ("next" === e.method) e.sent = e._sent = e.arg; else if ("throw" === e.method) {
                    if ("suspendedStart" === n) throw n = "completed", e.arg;
                    e.dispatchException(e.arg);
                } else "return" === e.method && e.abrupt("return", e.arg);
                n = "executing";
                var u = s(t, r, e);
                if ("normal" === u.type) {
                    if (n = e.done ? "completed" : "suspendedYield", u.arg === p) continue;
                    return {
                        value: u.arg,
                        done: e.done
                    };
                }
                "throw" === u.type && (n = "completed", e.method = "throw", e.arg = u.arg);
            }
        };
    }
    function _(t, r) {
        var e = r.method, n = t.iterator[e];
        if (void 0 === n) return r.delegate = null, "throw" === e && t.iterator.return && (r.method = "return", 
        r.arg = void 0, _(t, r), "throw" === r.method) || "return" !== e && (r.method = "throw", 
        r.arg = new TypeError("The iterator does not provide a '" + e + "' method")), p;
        var o = s(n, t.iterator, r.arg);
        if ("throw" === o.type) return r.method = "throw", r.arg = o.arg, r.delegate = null, 
        p;
        var i = o.arg;
        return i ? i.done ? (r[t.resultName] = i.value, r.next = t.nextLoc, "return" !== r.method && (r.method = "next", 
        r.arg = void 0), r.delegate = null, p) : i : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), 
        r.delegate = null, p);
    }
    function O(t) {
        var r = {
            tryLoc: t[0]
        };
        1 in t && (r.catchLoc = t[1]), 2 in t && (r.finallyLoc = t[2], r.afterLoc = t[3]), 
        this.tryEntries.push(r);
    }
    function j(t) {
        var r = t.completion || {};
        r.type = "normal", delete r.arg, t.completion = r;
    }
    function k(t) {
        this.tryEntries = [ {
            tryLoc: "root"
        } ], t.forEach(O, this), this.reset(!0);
    }
    function G(t) {
        if (t) {
            var r = t[c];
            if (r) return r.call(t);
            if ("function" == typeof t.next) return t;
            if (!isNaN(t.length)) {
                var e = -1, n = function r() {
                    for (;++e < t.length; ) if (o.call(t, e)) return r.value = t[e], r.done = !1, r;
                    return r.value = void 0, r.done = !0, r;
                };
                return n.next = n;
            }
        }
        return {
            next: N
        };
    }
    function N() {
        return {
            value: void 0,
            done: !0
        };
    }
    
    return v.prototype = y, i(x, "constructor", {
        value: y,
        configurable: !0
    }), i(y, "constructor", {
        value: v,
        configurable: !0
    }), v.displayName = h(y, l, "GeneratorFunction"), e.isGeneratorFunction = function(t) {
        var r = "function" == typeof t && t.constructor;
        return !!r && (r === v || "GeneratorFunction" === (r.displayName || r.name));
    }, e.mark = function(t) {
        return Object.setPrototypeOf ? Object.setPrototypeOf(t, y) : (t.__proto__ = y, h(t, l, "GeneratorFunction")), 
        t.prototype = Object.create(x), t;
    }, e.awrap = function(t) {
        return {
            __await: t
        };
    }, L(b.prototype), h(b.prototype, u, function() {
        return this;
    }), e.AsyncIterator = b, e.async = function(t, r, n, o, i) {
        void 0 === i && (i = Promise);
        var a = new b(f(t, r, n, o), i);
        return e.isGeneratorFunction(r) ? a : a.next().then(function(t) {
            return t.done ? t.value : a.next();
        });
    }, L(x), h(x, l, "Generator"), h(x, c, function() {
        return this;
    }), h(x, "toString", function() {
        return "[object Generator]";
    }), e.keys = function(t) {
        var r = Object(t), e = [];
        for (var n in r) e.push(n);
        return e.reverse(), function t() {
            for (;e.length; ) {
                var n = e.pop();
                if (n in r) return t.value = n, t.done = !1, t;
            }
            return t.done = !0, t;
        };
    }, e.values = G, k.prototype = {
        constructor: k,
        reset: function(t) {
            if (this.prev = 0, this.next = 0, this.sent = this._sent = void 0, this.done = !1, 
            this.delegate = null, this.method = "next", this.arg = void 0, this.tryEntries.forEach(j), 
            !t) for (var r in this) "t" === r.charAt(0) && o.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = void 0);
        },
        stop: function() {
            this.done = !0;
            var t = this.tryEntries[0].completion;
            if ("throw" === t.type) throw t.arg;
            return this.rval;
        },
        dispatchException: function(t) {
            if (this.done) throw t;
            var r = this;
            function e(e, n) {
                return a.type = "throw", a.arg = t, r.next = e, n && (r.method = "next", r.arg = void 0), 
                !!n;
            }
            for (var n = this.tryEntries.length - 1; n >= 0; --n) {
                var i = this.tryEntries[n], a = i.completion;
                if ("root" === i.tryLoc) return e("end");
                if (i.tryLoc <= this.prev) {
                    var c = o.call(i, "catchLoc"), u = o.call(i, "finallyLoc");
                    if (c && u) {
                        if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
                        if (this.prev < i.finallyLoc) return e(i.finallyLoc);
                    } else if (c) {
                        if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
                    } else {
                        if (!u) throw new Error("try statement without catch or finally");
                        if (this.prev < i.finallyLoc) return e(i.finallyLoc);
                    }
                }
            }
        },
        abrupt: function(t, r) {
            for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                var n = this.tryEntries[e];
                if (n.tryLoc <= this.prev && o.call(n, "finallyLoc") && this.prev < n.finallyLoc) {
                    var i = n;
                    break;
                }
            }
            i && ("break" === t || "continue" === t) && i.tryLoc <= r && r <= i.finallyLoc && (i = null);
            var a = i ? i.completion : {};
            return a.type = t, a.arg = r, i ? (this.method = "next", this.next = i.finallyLoc, 
            p) : this.complete(a);
        },
        complete: function(t, r) {
            if ("throw" === t.type) throw t.arg;
            return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, 
            this.method = "return", this.next = "end") : "normal" === t.type && r && (this.next = r), 
            p;
        },
        finish: function(t) {
            for (var r = this.tryEntries.length - 1; r >= 0; --r) {
                var e = this.tryEntries[r];
                if (e.finallyLoc === t) return this.complete(e.completion, e.afterLoc), j(e), p;
            }
        },
        catch: function(t) {
            for (var r = this.tryEntries.length - 1; r >= 0; --r) {
                var e = this.tryEntries[r];
                if (e.tryLoc === t) {
                    var n = e.completion;
                    if ("throw" === n.type) {
                        var o = n.arg;
                        j(e);
                    }
                    return o;
                }
            }
            throw new Error("illegal catch attempt");
        },
        delegateYield: function(t, r, e) {
            return this.delegate = {
                iterator: G(t),
                resultName: r,
                nextLoc: e
            }, "next" === this.method && (this.arg = void 0), p;
        }
    }, e;
}
window.babel_regeneratorRuntime = _regeneratorRuntime;
var _arrayLikeToArray = function(r, a) {
    (null == a || a > r.length) && (a = r.length);
    for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
    return n
}

var _unsupportedIterableToArray = function(r, e) {
    if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, e);
        var t = Object.prototype.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, e) : void 0
    }
}

var _createForOfIteratorHelper = function(r, e) {
    var t;
    if ("undefined" == typeof Symbol || null == r[Symbol.iterator]) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
            t && (r = t);
            var n = 0,
                o = function () {};
            return {
                s: o,
                n: function () {
                    return n >= r.length ? {
                        done: !0
                    } : {
                        done: !1,
                        value: r[n++]
                    }
                },
                e: function (r) {
                    throw r
                },
                f: o
            }
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")
    }
    var a, u = !0,
        i = !1;
    return {
        s: function () {
            t = r[Symbol.iterator]()
        },
        n: function () {
            var r = t.next();
            return u = r.done, r
        },
        e: function (r) {
            i = !0, a = r
        },
        f: function () {
            try {
                u || null == t.return || t.return()
            } finally {
                if (i) throw a
            }
        }
    }
}
window.babel_createForOfIteratorHelper = _createForOfIteratorHelper;


var _getPrototypeOf = function(t) {
    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
        return t.__proto__ || Object.getPrototypeOf(t);
    }, _getPrototypeOf(t);
}


var _superPropBase = function(e, r) {
    for (;!Object.prototype.hasOwnProperty.call(e, r) && null !== (e = _getPrototypeOf(e)); ) ;
    return e;
}

var _get = function() {
    return "undefined" != typeof Reflect && Reflect.get ? _get = Reflect.get.bind() : _get = function(e, t, r) {
        var o = _superPropBase(e, t);
        if (o) {
            var p = Object.getOwnPropertyDescriptor(o, t);
            return p.get ? p.get.call(arguments.length < 3 ? e : r) : p.value;
        }
    }, _get.apply(this, arguments);
}
window.babel_get = _get;
var _typeof = function(o) {
    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
        return typeof o;
    } : function(o) {
        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
    }, _typeof(o);
}


var _assertThisInitialized = function(e) {
    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    return e;
}

var _possibleConstructorReturn = function(e, r) {
    if (r && ("object" === _typeof(r) || "function" == typeof r)) return r;
    if (void 0 !== r) throw new TypeError("Derived constructors may only return object or undefined");
    return _assertThisInitialized(e);
}
window.babel_possibleConstructorReturn = _possibleConstructorReturn;
var _getPrototypeOf = function(t) {
    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
        return t.__proto__ || Object.getPrototypeOf(t);
    }, _getPrototypeOf(t);
}
window.babel_getPrototypeOf = _getPrototypeOf;
var _setPrototypeOf = function(t, e) {
    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t, e) {
        return t.__proto__ = e, t;
    }, _setPrototypeOf(t, e);
}


var _inherits = function(e, t) {
    if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function");
    e.prototype = Object.create(t && t.prototype, {
        constructor: {
            value: e,
            writable: !0,
            configurable: !0
        }
    }), Object.defineProperty(e, "prototype", {
        writable: !1
    }), t && _setPrototypeOf(e, t);
}
window.babel_inherits = _inherits;
var _classCallCheck = function(a, l) {
    if (!(a instanceof l)) throw new TypeError("Cannot call a class as a function");
}

// module.exports = _classCallCheck;
// window._classCallCheck = _classCallCheck;
window.babel_classCallCheck = _classCallCheck;
var _defineProperties = function(e, r) {
    for (var t = 0; t < r.length; t++) {
        var n = r[t];
        n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), 
        Object.defineProperty(e, n.key, n);
    }
}

var _createClass = function(e, r, t) {
    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), e;
}
window.babel_createClass = _createClass;